Scala Specification

1. Лексичний синтаксис

Програми Scala пишуться з використанням набору символів Unicode Basic Multilingual Plane (BMP); додаткові символи Unicode наразі не підтримуються. Ця глава визначає два режими лексичного синтаксису Scala, режим Scala та XML режим. кщо не вказане інше, наступні дескриптори токенів Scala посилаються на режим Scala, та літеральні символи ‘c’ посилаються на фрагмент ASCII \u0000 – \u007F.

В режимі Scala, виключення Unicode замінюються на відповідні символи Unicode з наданим шістнацятиричним кодом.

UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’

Щоб побудувати токени, символи визначаються за наступними класами (загальна категорія Unicode надається в дужках):

1. Проміжні символи. \u0020 | \u0009 | \u000D | \u000A.
2. Літери, що включають малі літери (Ll), великі літери (Lu), заголовні літери (Lt), інші літери (Lo), літери-цифри (Nl) та два символи,  \u0024 ‘$’ та \u005F ‘_’, що обоє вважаються за великі літери.
3. Цифри ‘0’ | … | ‘9’.
4. Дужки ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’.
5. Символи-роздільники ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’.
6. Символи-оператори. Це складається з усіх друкованих смволах ASCII \u0020 - \u007F, що не входять до наборів вище, математичні символи (Sm) та інші символи (So).

Ідентифікатори

op       ::=  opchar {opchar}
varid    ::=  lower idrest
plainid  ::=  upper idrest
           |  varid
           |  op
id       ::=  plainid
           |  ‘`’ stringLiteral ‘`’
idrest   ::=  {letter | digit} [‘_’ op]

Є три способи сформувати ідентифікатор. Перше, ідентифікатор може починатись з довільної послідовності літер та цифр. За цім може слідувати символи підкреслення ‘_‘ та інші рядки, що складаються з літер та цифр, або символи операторів. Друге, ідентифікатор може починатись з символа оператора, за яким може слідувати довільна послідовність символів операторів. Ці дві форми називаються простими ідентифікаторами. Нарешті, ідентифікатор може також формуватись з довільного рядка між зворотніми лапками (різні системи можуть накладати деякі обмеження до того, які рядки легальні в якості ідентифікаторів). Самий ідентифікатор складається з усіх символів, за винятком зворотніх лапок. 

Як звичайно, застосовується найбільше співпадіння. Наприклад, рядок 

big_bob++=`def`

розбивається на три ідентифікатори, big_bob, ++=, та def. Правила для порівняння з шаблоном додатково розрізняє між ідентифікаторами змінних, які починаються з малих літер, та ідентифікаторами констант, що ні.

Символ ‘$’ зарезервовано для синтезованих компілятором ідентифікаторів. Користувацькі програми не повинні визначати ідентифікатори, що мають символи ‘$’.

Наступні імена є зарезарвованими словами, замість бути членами id синтаксичного класу  або лексічними ідентифікаторами. 

abstract    case        catch       class       def
do          else        extends     false       final
finally     for         forSome     if          implicit
import      lazy        macro       match       new
null        object      override    package     private
protected   return      sealed      super       this
throw       trait       try         true        type
val         var         while       with        yield
_    :    =    =>    <-    <:    <%     >:    #    @

Оператори Unicode \u21D2 ‘⇒’ та \u2190 ‘←’, що мають еквіваленти в ASCII => та <-, також зарезервовані, .

Ось приклади ідентифікаторів:

    x         Object        maxIndex   p2p      empty_?
    +         `yield`       αρετη     _y       dot_product_*
    __system  _MAX_LEN_

Коли треба отримати доступ до Java ідентифікаторів, що є зарезервованими словами в Scala, використовуйте рядки в зворотніх лапках. Наприклад, твердження  Thread.yield() є нелегальним, оскільки yield є зарезервованим словом в Scala. Однак наступне є обхідним шляхом: Thread.`yield`()

Символи нового рядка

semi ::= ‘;’ |  nl {nl}

Scala є рядок-орієнтованою мовою, де твердження можуть бути завершені крапкою з комою, або новим рядком. Новий рядок в джерельному тексті Scala трактується як специальний токен “nl”, якщо задовільняються три критерії:

1. Токен, що безпосередньо передує новому рядку, може завершити твердження. 
2. Токен, що безпосередньо слідує за новим рядком, може почати твердження.
3. Токен з'являється в регіоні, де дозволені нові рядки. 

Токени, що можуть завершити твердження, такі: літерали, ідентифікатори та роздільники та зарезервовані слова:

this    null    true    false    return    type    
_       )       ]       }

Токени, що можуть починати твердження, є всі токени Scala,  за винятком наступних роздільників та зарезервованих слів:

catch    else    extends    finally    forSome    match
with    yield    ,    .    ;    :    =    =>    <-    <:    <%
>:    #    [    )    ]    }

Токен case може починати твердження, тільки якщо слідує за токенами  class або object.

Нові рядки дозволені у:

1. всіх джерельних файлах Scala, за виключення вкладених регіонів, да нові рядки відключені, та
2. інтервалах між парними токенами фігурних дужок {  }, за виключенням вкладених регіонів, де нові рядки відключені.

Нові рядки відключені у:

1. інтервалах між парними токенами дужок ( та ), за виключенням вкладених регіонів, де нові рядки дозволені, та 
2. інтервалах між парними токенами кладратних дужок[ та ], за виключенням вкладених регіонів, де нові рядки дозволені. 
3. Інтервал між токеном case та його співпадаючим токеном  =>, за винятком вкладених регіонів, що нові рядки дозволені.
4. Любих регіонах, що аналізуються в режимі XML.

Занотуйте, що фігурні дужки {...} заекрановані в XML, та рядкові літерали не є токенами, і, таким чином, не замикають регіон, де включені нові рядки. 

Звичайно, вставляється тільки один токен nl між двома послідовними токенами не-новими-рядками, що є на різних рядках, навіть якщо між двома токенами більше одного рядка. Однак, якщо два токени розділені щонайменьше одним повністю пустим рядком (тобто рядком, що не містить друкованих символів), тоді вставляються два токени nl.

Граматика Scala (повністю надана тут) містить конструкції, де допустимі опціональні nl, але но додаткові крапки з комою. Це має ефект, що новий рядок на одній з ціх позицій не завершують вираз або твердження. Ці позиції можуть бути підсумовані наступним чином:

Декілька токенів нових рядків допустимі в наступних місцях (зауважте, що крапка з комою замість нового рядка може бути нелегальним в кожному з ціх випадків):

• між умовою умовного виразу або циклу while та слідуючим наступним виразом,
• між енумераторами for-осмислення та слідуючим наступним виразом, та
• після початковим ключовим словом type в визначенні або декларації типу.

Поодинокий токен нового рядка прийнятний

• перед відкриваючою фігурною дужкою ‘{’, якщо дужка є легальним продовженням потокчного твердження або виразу,
• після інфіксного оператору, якщо перший токен на наступному рядку може починати вираз,
• спереду визначення параметру, та
• після анотації.

Токени нового рядка між двома рядками не трактуються як роздільники тверджень.

if (x > 0)
  x = x - 1

while (x > 0)
  x = x / 2

for (x <- 1 to 10)
  println(x)

type
  IntList = List[Int]

new Iterator[Int]
{
  private var x = 0
  def hasNext = true
  def next = { x += 1; x }
}

З додатковим символом нового рядка той же код інтерпретується як створення об'єкта, за яким слідує локальний блок:

new Iterator[Int]

{
  private var x = 0
  def hasNext = true
  def next = { x += 1; x }
}

  x < 0 ||
  x > 10

З додатковим символом нового рядка той же код інтерпретуюється як два вираза:

  x < 0 ||

  x > 10

def func(x: Int)
        (y: Int) = x + y

З додатковим символом нового рядка той же код інтерпретується як визначення абстрактної функції, та синтаксично нелегального твердження:

def func(x: Int)

        (y: Int) = x + y

@serializable
protected class Data { ... }

З додатковим символом нового рядка той же код інтерпретується як атрибут та окреме твердження (що синтаксично нелегально).

@serializable

protected class Data { ... }

Літерали

Є літерали для цілих чисел, чисел з плаваючою крапкою, символів, логічних, символічних та рядків. Синтаксис ціх літералів в кожному випадку такий же, як в Java.

Literal  ::=  [‘-’] integerLiteral
           |  [‘-’] floatingPointLiteral
           |  booleanLiteral
           |  characterLiteral
           |  stringLiteral
           |  symbolLiteral
           |  ‘null’

Цілі літерали

integerLiteral  ::=  (decimalNumeral | hexNumeral)
                       [‘L’ | ‘l’]
decimalNumeral  ::=  ‘0’ | nonZeroDigit {digit}
hexNumeral      ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
digit           ::=  ‘0’ | nonZeroDigit
nonZeroDigit    ::=  ‘1’ | … | ‘9’

Цілі літерали звичайно мають тип Int, або тип Long, якщо за ним слідує суфікс L або l. Значення типу Int є всі цілі числа в межах −231 та 231−1, включно. Значення типу Long є всі цілів межах −263 та 263−1, включно. Помилки часу компіляції виникають, якщо цілий літерал не підпадає в ці диапазони.

Однак, якщо очікуваний тип pt літерала у виразі є Byte, Short, або Char, та ціле число в межах, що визначені типом, тоді число конвертується до типу pt і тип літерала є pt. Числові диапазони, надані цім типам, наступні:

0          21          0xFFFFFFFF       -42L

Літерали з плаваючою крапкою

floatingPointLiteral  ::=  digit {digit} ‘.’ digit {digit} [exponentPart] [floatType]
                        |  ‘.’ digit {digit} [exponentPart] [floatType]
                        |  digit {digit} exponentPart [floatType]
                        |  digit {digit} [exponentPart] floatType
exponentPart          ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit}
floatType             ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’

Літерали з плаваючою крапкою є типу Float, коли за типом з плаваючою крапкою слідує суфікс F або f, та типу Double в іншому порядку. Тип Float складається з усіх 32-бітних значень одинарної точності з плаваючою крапкою, що задовільняють IEEE 754, тоді як Double складається з 64-бітних значень подвійної точності.

Якщо за літералом з плаваючою крапкою в програмі слідує літера, має бути щонайменьше один символ проміжку між двома токенами.

0.0        1e30f      3.14159f      1.0e-100      .1

Фраза 1.toString розкладається на три різні токени: ціле-літерал 1, крапка ., та ідентифікатор toString.

1. не є дійсним літералом з плаваючою крапкою, оскільки відсутня обов'язкова цифра після крапки.

Логічні літерали

booleanLiteral  ::=  ‘true’ | ‘false’

Логічні літерали true та false є членами типу Boolean.

Символьні літерали

characterLiteral  ::=  ‘'’ (printableChar | charEscapeSeq) ‘'’

Символьні літерали є поодиноким символом у лапках. Символ або друкований символ юнікод або описаний як екранована послідовність.

'a'    '\u0041'    '\n'    '\t'

Зауважте, що '\u000A' не є дійсним символьним літералом, оскільки перетворення Unicode відбувається перед розбором літерала, та символ Unicode \u000A (переведення рядка) не є друкованим символом. Замість цього можна використати екрановану послідовність '\n' або восьмирічну послідовність '\12'(дивіться тут).

Літеральні рядки

stringLiteral  ::=  ‘"’ {stringElement} ‘"’
stringElement  ::=  printableCharNoDoubleQuote  |  charEscapeSeq

Літеральний рядок є послідовністю символів в подвійних лапках. Символи є або друкованими символами юнікоду, або визначені як екрановані послідовності. Якщо літеральний рядок містить символ подвійних лапок, він може бути екранований як "\"". Значення рядкового літералу є примірником класу String.

"Hello,\nWorld!"
"This string contains a \" character."

Багато-рядкові літерали String

stringLiteral   ::=  ‘"""’ multiLineChars ‘"""’
multiLineChars  ::=  {[‘"’] [‘"’] charNoDoubleQuote} {‘"’}

Багато-рядковий рядковий літерал є послідовністю символів, заключених в потрійні лапки """ ... """. Послідовність символів довільна, за тим виключенням, що вона може містити три або більше послідовних символів подвійних лапок тільки в самому кінці. Символи не обов'язково мають бути друкованими. Екранування Unicode робить як у всіх інших місцях, але жодне з екранованих послідовностей тут не інтерпретуються.

  """the present string
     spans three
     lines."""

Це буде продукувати рядок:

the present string
     spans three
     lines.

Бібліотека Scala містить допоміжний метод stripMargin, що може бути використаний для видалення проміжків напочатку багато-рядкових літералів. Вираз

 """the present string
   |spans three
   |lines.""".stripMargin

обчислюється до

the present string
spans three
lines.

Метод stripMargin визначений в класі scala.collection.immutable.StringLike. Оскільки існує передвизначене неявне перетворення зі String на StringLike, метод стосується до всіх рядків. 

Екрановані послідовності

Наступні екрановані послідовності різпознаються в символьних та рядкових літералах.

Символ з Unicode між 0 та 255 може бути також представлено як екрановане восьмиричне, точто як коса '\', за якою слідує послідовність до трьох восьмиричних символів.

Буде помилкою часу компіляції, якщо за символом косої лінії в символьному або рядковому літералі не починається дійсна екранована послідовність. 

Символічні літерали

symbolLiteral  ::=  ‘'’ plainid

Символічний літерал 'x є скороченням для виразу scala.Symbol("x"). Symbol є кейс класом, що визначений наступним чином.

package scala
final case class Symbol private (name: String) {
  override def toString: String = "'" + name
}

Метод apply компанійського об'єкту Symbol кешує слабкі посилання на Symbol, таким чином забезпечуючи, що ідентичні символічні літерали еквівалентні з точки зору еквівалентності посилань. 

Проміжки та коментарі

Токени можуть бути розділені символами-проміжками та/або коментарями. Коментарі слідують в двох формах:

Одно-рядкові коментарі є послідовністю символів, що починаються з // , та продовжуються до кінця рядка.

Багато-рядковий коментар є послідовністю символів між /* та */. Багато-рядкові коментарі можуть бути вкладені, але мають бути вірно вкладеними. Таким чином, коментар як /* /* */ буде відхілений, як такий, що незачинений. 

Режим XML

Щоб дозволити літеральні включення з XML фрагментів, лексічний аналіз перемикається з режиму Scala до режиму XML, коли натрапляє на відкливаючу кутову дужку, ‘<’, за наступних умов: ‘<’ має бути попереджений проміжком, відкритими дужками або фігурними дужками, та безпосередньо за ним має іти символ ім'я XML.

 ( whitespace | ‘(’ | ‘{’ ) ‘<’ (XNameStart | ‘!’ | ‘?’)

  XNameStart ::= ‘_’ | BaseChar | Ideographic // as in W3C XML, but without ‘:’

Сканер перемикається з режиму XML до режиму Scala за наступної умови

• вираз XML або шаблон XML, що починався з початкового ‘<’ був успішно розібраний, або коли
• парсер натрапляє на вбудований вираз Scala або шаблон, та змушує сканер повернутись до звичайного режима, доки вираз або шаблон Scala не буде успішно розібраний. В цьому випадку, оскільки код та фрагменти XML можуть бути вкладені, парсер має підтримувати стек, що адекватно відображує вкладення виразів XML та Scala.

Зауважте, що токени Scala конструюються в XML режимі, та що коментарі інтерпретуються як текст.

Наступнє визначення значення використовує XML літерал з двома вбудованими виразами Scala:

val b = 
          
          {scalaBook.version}
          {scalaBook.authors.mkList("", ", ", "")}
        

2. Ідентифікатори, імена, сфери бачення

Імена в Scala ідентифікують типи, значення, методи та класи, що загалом називаються сутностями. Імена вводяться локальними визначеннями та деклараціями, наслідуванням, положеннями імпорту, або положеннями пакунків, що колективно називаються прив'язками.

Прив'язки різних типів мають визначене для них старшинство:

1. Визначення та декларації, що є локальними, наслідуваними, або зроблені доступними за допомогою положень package в тій же одиниці компіляції, де трапляється визначення, мають найвищу перевагу. 
2. Явні імпорти мають наступне старшинство.
3. Узагальнені імпорти мають слідуючий приорітет. 
4. Визначення, зроблені доступними за допомогою положення package, не в тій одиниці компіляції, де трапляється визначення, мають найнижчий приорітет.

Існує два різних простору імен, одне для типів та один для термів. Те ж ім'я може позначати тип та терм, в залежності від контексту, де використовується ім'я.

Прив'язка має сферу , в якій визначена єдиним іменем сутність може бути доступною за допомогою простого імені. Сфери вкладені. Прив'язка в деякій внутрішній сфері затінює  прив'язки меньшого приорітету в тій же сфері, так само, як прив'язки такого ж, або нижчого приорітету, у зовнішніх сферах. 

Посилання до некваліфікованого ідентифікатора (типу- або терміну-) x обмежене до унікальної прив'язки, що

• визначає сутність з ім'ям x в тому ж просторі імен, що і ідентифікатор, та
• затінює всі інші прив'язки, що визначають сутностіз ім'ям  x в цьому просторі імен.

Буде помилкою, якщо така прив'язка не існує. Якщо x обмежений до import, тоді просте ім'я x береться еквівалентним до кваліфікованого імені, до якого x відображується положенням import. Якщо x обмежений визначенням або декларацією, тоді x посилається до сутності, введеною цією прив'язкою. В цьому випадку, типом x є типом сутності, на яку він посилається. 

Посилання на кваліфікований ідентифікатор (типу- або терму-),  e.x посилається на член типу T з e , що має ім'я x в тому ж просторі імен, що і ідентифікатор. Буде помилкою, якщо T не є типом значення. Типом e.x є тип члену, на яку посилається в T.

Приклад

Нехай є два наступні визначення об'єктів, з іменами X в пакунках P та Q.

package P {
  object X { val x = 1; val y = 2 }
}

package Q {
  object X { val x = true; val y = "" }
}

Наступна програма ілюструє різні типи прив'язок, та відносини старшості між ними. 

package P {                  // `X' прив'язане через package
import Console._             // `println' прив'язане через узагальнений import
object A {
  println("L4: "+X)          // `X' посилається на `P.X'
  object B {
    import Q._               // `X' прив'язаний через узагальнений import
    println("L7: "+X)        // `X' тут посилається на `Q.X'
    import X._               // `x' та `y' прив'язані через узагальнений import
    println("L8: "+x)        // `x' тут посилається на `Q.X.x'
    object C {
      val x = 3              // `x' прив'язаний локальним визначенням
      println("L12: "+x)     // `x' тут посилається на константу `3'
      { import Q.X._         // `x' та `y' прив'язані через узагальнений import
//      println("L14: "+x)   // посилання на `x' тут неоднозначне
        import X.y           // `y' прив'язане явним import
        println("L16: "+y)   // `y' тут посилається на `Q.X.y'
        { val x = "abc"      // `x' прив'язане локальним визначенням
          import P.X._       // `x' та `y' прив'язані узагальненим import
//        println("L19: "+y) // посилання на `y' тут неоднозначне
          println("L20: "+x) // `x' тут посилаєтся на "abc"
}}}}}}

3. Типи

  Type              ::=  FunctionArgTypes ‘=>’ Type
                      |  InfixType [ExistentialClause]
  FunctionArgTypes  ::=  InfixType
                      |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
  ExistentialClause ::=  ‘forSome’ ‘{’ ExistentialDcl
                             {semi ExistentialDcl} ‘}’
  ExistentialDcl    ::=  ‘type’ TypeDcl
                      |  ‘val’ ValDcl
  InfixType         ::=  CompoundType {id [nl] CompoundType}
  CompoundType      ::=  AnnotType {‘with’ AnnotType} [Refinement]
                      |  Refinement
  AnnotType         ::=  SimpleType {Annotation}
  SimpleType        ::=  SimpleType TypeArgs
                      |  SimpleType ‘#’ id
                      |  StableId
                      |  Path ‘.’ ‘type’
                      |  ‘(’ Types ‘)’
  TypeArgs          ::=  ‘[’ Types ‘]’
  Types             ::=  Type {‘,’ Type}

Ми робимо різницю між першого порядку та конструкторами типів, що сприймають параметри тиів, та віддають типи. Підмножина типів першого порядку називаються типами значень, що представляють набори (першокласних) значень. Типи значень є або конкретними або абстрактними.

Кожне конкретне значення може бути представлене тип класу, тобто покажчиком типу, що посилаєтся на клас або трейт ¹, або як складний тип, що представляє перетин типів, можливо з уточнення, що ще обмежує типи своїх членів.

Абстрактні типи даних введені параметрами типів та абстрактними прив'язками типів. Дужки в типах можуть використовуватись для групування.

Типи не-значень захоплюють властивості ідентифікаторів, що не є значеннями. Наприклад, конструктор типу не задає напряму тип значень. Однак, коли конструктор типу застосовується з коректними аргументами типу, він надає тип першого порядку, що може бути типом значення.

Типи не-значень виражені неявно в Scala. Тобто, метод типу описується, записуючи сигнатуру метода, що насправді не є реальним типу, хоча воно породжує відповідний тип методу. Конструктори типу є іншим прикладом, так що можна записати Swap[m[_, _], a,b] = m[b, a], але немає синтаксиса для запису відповідного анонімного типу функції напряму.

Шляхи

Path            ::=  StableId
                  |  [id ‘.’] this
StableId        ::=  id
                  |  Path ‘.’ id
                  |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
ClassQualifier  ::= ‘[’ id ‘]’

Шляхи не є типами самі по собі, але вони можуть бути частиною імен типів, та в цій функції формують центральну роль в системі типів Scala.

Шляхом є одне з наступних.

• Пустий шлях  ε (що не може бути записаний явно в користувацьких програмах).
• C.this, де C посилається на клас. Шлях this береться як скорочення для C.this де C є ім'ям класу, що напряму замикає посилання.
• p.x , де p є шляхом, та x є стабільним членом p. Чтабільні члени є пакетами або членами, що вводяться визначенням об'єкта або визначенням об'єкта не-непостійних типів.
• C.super.x або C.super[M].x, де C посилається на клас, та x посилаєтся на стабільний член суперкласу або призначений батьківський клас M відносно C. Префікс super береться як скорочення до C.super, де C є ім'ям класу, що напряму замикає посилання.

Стабільний ідентифікатор є шляхом, що завершується на ідентифікатор.

Типи значень

Кожне значення в Scala має тип, що є однією з наступних форм.

Типи сінглтони

SimpleType  ::=  Path ‘.’ type

Тип-синглтон є форма p.type, де p є шляхом, що вказує на значення, що очікувано відповідає до scala.AnyRef. Тип визначає набір значень, що складаються з null та значення, визначеного p.

Стабільний тип є або тип-синглтон, або тип, що декларований як субтип трейту scala.Singleton.

Проекція типу

SimpleType  ::=  SimpleType ‘#’ id

Проекція типу T#x посилається на член типу з ім'ям x типу T.

Визначники типу

SimpleType  ::=  StableId

Визначник типу посилаєтся на іменоване значення типу. Він може бути простим або кваліфікованим. Всі таки визначники типу є скороченнями до проекцій типу. 

Зокрема, некваліфіковане ім'я типу t , де t прив'язане до деякого класу, об'єкту, або пакунку C береться як скорочення до C.this.type#t. Якщо t не є обмеженим до класу, об'єкту або пакунку, тоді t береться як скорочення для ε.type#t.

Кваліфікований визначник типу має форму p.t , де p є шляхом та t є ім'ям типу. Такий визначник типу еквівалентний до проекції типу p.type#t.

Приклад

Деякі визначники типу та їх розширення перелічені нижче. Ми маємо на увазі локальний параметр типу t, значення  maintable з членом типу Node ,та стандартний клас scala.Int,

Параметризовані типи

SimpleType      ::=  SimpleType TypeArgs
TypeArgs        ::=  ‘[’ Types ‘]’

Параметризований тип T[T1,…,Tn] складається з визначника типу T та типових параметрів T1,…,Tn , де n≥1. T має посилатись на конструктор типу, що сприймає n параметрів типу a1,…,an.

Скажімо, параметри типу мають нижчі межі L1,…,Ln та вищі межі U1,…,Un. Параметризований тип гарно сформований, якщо кожний дійсний параметр типу відповідає до його меж, тобто σLi<:Ti<:σUi де σ є підстановкою [a1:=T1,…,an:=Tn].

Приклад параметризованих типів

Візьмемо часткові візначення типів:

class TreeMap[A <: Comparable[A], B] { … }
class List[A] { … }
class I extends Comparable[I] { … }

class F[M[_], X] { … }
class S[K <: String] { … }
class G[M[ Z <: I ], I] { … }

наступні параметризовані типи є гарно сформованими:

TreeMap[I, String]
List[I]
List[List[Boolean]]

F[List, Int]
G[S, String]

Приклад

Беручи до уваги зазначені вище визначення, наступні типи є хворобливо-зформованими:

TreeMap[I]            // недійсне: помилкове число параметрів
TreeMap[List[I], Int] // недійсне: параметр типу не в межах

F[Int, Boolean]       // недійсне: Int не є конструктором типу
F[TreeMap, Int]       // недійсне: TreeMap приймає два параметри,
                      //   F очікує конструктор, що сприймає один
G[S, Int]             // недійсне: S cобмежує свій параметр відповідним до String,
                      // G очікує конструктор типу з параметром, що відповідає Int

Кортежні типи

SimpleType    ::=   ‘(’ Types ‘)’

Кортежний тип (T1,…,Tn) є псевдонимом до класу scala.Tuplen[T1, … , Tn], де n≥2.

Кортежні класи є кейс-класи, чиї поля можуть бути доступні через селектори _1 , … , _n. Їх функціональність абстрагована в відповідному трейті Product. n-арний кортежний клас та вироблений трейт визначені щонайменьше як наступне в стандартній бібліотеці Scala (вони можуть також додавати інші методи та реалізувати інші трейти).

case class Tuplen[+T1, … , +Tn](_1: T1, … , _n: Tn)
extends Product_n[T1, … , Tn]

trait Product_n[+T1, … , +Tn] {
  override def productArity = n
  def _1: T1
  …
  def _n: Tn
}

Анотовані типи

AnnotType  ::=  SimpleType {Annotation}

Анотований тип  T a1,…,an приєднує анотації a1,…,an до типу T.

Приклад

Наступний тип додає анотацію @suspendable до типу String:

String @suspendable

Складні типи

CompoundType    ::=  AnnotType {‘with’ AnnotType} [Refinement]
                  |  Refinement
Refinement      ::=  [nl] ‘{’ RefineStat {semi RefineStat} ‘}’
RefineStat      ::=  Dcl
                  |  ‘type’ TypeDef
                  |

Складний тип T1 with … with Tn{R} представляє об'єкти з членами, як надано в складових типах T1,…,Tn та уточнення {R}. Уточнення {R} містить декларації та визначення типів. Якщо декларація або визначення перекриває декларації або визначення в одному з компонентниї типів T1,…,Tn, застосовуються звичайні правила перекриття; інакше про декларацію та визначення кажуть як про “структурні” ².

В декларації методу в структурному уточненні, тип кожного значення-параметру може тільки посилатись на параметри типів або абстрактні типи, що містяться в уточненні. Тобто він має посилатись на параметр типу самого методу, або на визначення типу в уточненні. Це обмеження не стосується до результуючого типу методу.

Якщо надане уточнення, додається явне пусте уточнення, тобто T1 with … with Tn є скороченням для T1 with … with Tn{}.

Складний тип може також складатись тільки з уточнення {R} без попередніх компонентних типів. такий тип еквівалентний до AnyRef {R}.

Приклад

Наступний приклад показує, як декларувати та використовувати метод, який є паметром-типом, що містить уточнення з структурованими деклараціями.

case class Bird (val name: String) extends Object {
        def fly(height: Int) = …
…
}
case class Plane (val callsign: String) extends Object {
        def fly(height: Int) = …
…
}
def takeoff(runway: Int, r: { val callsign: String; def fly(height: Int) }) = {
  tower.print(r.callsign + " потребує злету на полосі " + runway)
  tower.read (r.callsign + " готовий до злету")
  r.fly(1000)
}
val bird = new Bird("Polly the parrot"){ val callsign = name }
val a380 = new Plane("TZ-987")
takeoff(42, bird)
takeoff(89, a380)

Хоча Bird та Plane не поділяють жодного батьківського класу, окрім Object, параметр r методу takeoff визначений за допомогою уточнення зі структурною декларацією сприймати любий об'єкт, що декларує значенняcallsign та метод fly.

Інфіксні типи

InfixType     ::=  CompoundType {id [nl] CompoundType}

Інфіксний тип T1 op T2 складається з інфіксного оператора op, що застосовується до двох операторів типу T1 та T2. Тип еквівалентний до типу застосування op[T1,T2]. Інфіксний оператор op може бути довільним ідентифікатором.

Всі інфіксні оператори типів мають однаковий приоритет; дужки можуть застосовуватись для групування. Асоціативність типового оператора визначається як для термових операторів: оператори типів, що закінчуються на дві крапки ‘:’ є право-асоциативними; всі інші є ліво-асоциативними.

В послідовності типових інфіксних операторів t0op t1op2…opntn, всі оператори op1,…,opn повинні мати однакову асоціативність. Якщо вони є ліво-асоціативними, послідовність інтерпретується як (…(t0op1t1)op2…)opntn, інакше вони інтерпретуються як  t0op1(t1op2(…opntn)…).

Функціональні типи

Type              ::=  FunctionArgs ‘=>’ Type
FunctionArgs      ::=  InfixType
                    |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’

Тип (T1,…,Tn)⇒U представляє набір значень функцій, що сприймають аргументи типів T1,…,Tn та отримують результат типу U. В випадку тільки одного аргументу типу T⇒U є скороченням для (T)⇒U. Аргумент типу в формі ⇒T представляє викликаний-за-ім'ям параметр типу T.

Функціональні типи асоціюються зправа, тобто S⇒T⇒U те ж саме, що і S⇒(T⇒U).

Функціональні типи є скороченнями для класових типів, що визначають функції apply. Зокрема, n-арний функціональний тип (T1,…,Tn)⇒U є скороченням для класового типу Functionn[T1 , … , Tn, U]. Такі класові типи визначені в бібліотеці Scala для n від 0 до 9 наступним чином.

package scala
trait Function_n[-T1 , … , -Tn, +R] {
  def apply(x1: T1 , … , xn: Tn): R
  override def toString = ""
}

Таким чином, функціональні типи є коваріантними в частині результуючого типу, та контрваріантними за типами аргументів.

Екзистенціальні типи

Type               ::= InfixType ExistentialClauses
ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl
                       {semi ExistentialDcl} ‘}’
ExistentialDcl     ::= ‘type’ TypeDcl
                    |  ‘val’ ValDcl

Екзистенціальний тип має форму T forSome { Q }, де Q є послідовністю декларацій типів.

Нехай t1[tps1]>:L1<:U1,…,tn[tpsn]>:Ln<:Un будуть типами, задекларованими в Q (жодні з розділів параметрів типів [ tpsi ]можуть бути відсутніми). Сферою кожного типу ti включає тип T та екзистенціальне твердження Q. Типові змінні  ti кажуть, є зв'язаними в типі T forSome { Q }. Змінні типу, що зустрічаються в типі T , але які не зв'язані в T , кажуть, є вільними в T.

примірник типу з T forSome { Q } є типом σT , де σ є заміщенням над t1,…,tn, таким що для кожного i, σLi<:σti<:σUi. Набір значень, позначений екзістенціальним типом T forSome {Q} , є об'єднанням множини значень всіх його примірників типів. 

Сколемізація T forSome { Q } є примірником типу σT, де σ є заміною [t′1/t1,…,t′n/tn], та кожний t′i є свіжим абстрактним типом, чия нижня межа є σLi, та верхня межа σUi.

Правила спрощення

Екзістенціальні типи дотримуються таким чотирьом еквівалентностям:

1. Декілька for-твержень екзестенціального типу можуть бути поєднані. Тобто, T forSome { Q } forSome { Q′ } еквівалентно до T forSome { Q ; Q′}.
2. Невикористані кваліфікатори можуть бути відкинуті. Тобто, T forSome { Q ; Q′}, де жодний з типів, визначених в  Q′ не посилаються в T або Q, еквівалентно до  T forSome {Q}.
3. Пуста квантифікація може біти відкинута. Тобто, T forSome { } еквівалентно до T.
4. Екзістенціальний тип T forSome { Q }, де Q містить твердження type t[tps]>:L<:U , є еквівалентним до типу typeT′ forSome { Q }, де T′ отримується з T заміною кожного  коваріантного входження t в T на U, та заміщенням кожного контрваріантного входження t в T на L.

Екзістенціальна квантифікація проти значень

За синтаксичної домовленості, твердження прив'язки в екзістенціальному типі може також містити декларації значення val x: T. Екзістенціальний тип  T forSome { Q; val x: S;Q′ } трактується як скорочення для типу T′ forSome { Q; type t <: S with Singleton; Q′ }, де  t свіжим ім'ям типу T′ , що отримується з T заміною кожного входження x.type на t.

Синтаксис заповнювача для екзистенціальних типів

WildcardType   ::=  ‘_’ TypeBounds

Scala підтримує синтаксис заповнювача для екзестенціальних типів. Узагальнений тип записується у формі _>:L<:U. Обоє тверджень межі можуть бути відсутні. Якщо нижнє обмежувальне твердження  >:L відсутнє, передбачається >:scala.Nothing. Якщо відсутня верхня межа <:U, передбачаєтся <:scala.Any. Узагальнені типи є скороченням до екзостенціальних квантифікованих змінних типів, де екзистенціальна квантифікація є неявною.

Узагальнений тип має з'являтись як аргумент типу параметризованого типу. Нехай T=p.c[targs,T,targs′] буде параметризованим типом, де  targs,targs′  може бути пустим, та T є узагальненим типом _>:L<:U. Тоді T є еквівалентним до екзистенціального типу

p.c[targs,t,targs′] forSome { type t >: L <: U }

де t є деякою свіжою змінною типу. Узагальнені типи також можуть з'являтись як частини інфіксних типів, функціональних типів, або кортежних типів. Їхнє розширення потім є розширенням в еквіваентному параметризованого типу. 

Приклад

Розглянемо визначення класу

class Ref[T]
abstract class Outer { type T } .

Ось декілька прикладів екзистенціальних типів:

Ref[T] forSome { type T <: java.lang.Number }
Ref[x.T] forSome { val x: Outer }
Ref[x_type # T] forSome { type x_type <: Outer with Singleton }

Останні два типи в цьому списку еквівалентні. Альтернативне формолювання першого тпу вище, з використанням узагальнуючого синтаксису:

Ref[_ <: java.lang.Number]

Приклад

Тип List[List[_]] еквівалентний до екзістенціального типу

List[List[t] forSome { type t }] .

Приклад

Розглянемо коваріантний тип

class List[+T]

Тип

List[T] forSome { type T <: java.lang.Number }

еквівалентний (за правилом спрощення 4 вище) до такого

List[java.lang.Number] forSome { type T <: java.lang.Number }

що, в свою чергу, еквівалентний (за правилами спрощення 2 та 3 вище) до  List[java.lang.Number].

Типи не-значень

Типи, описані в наступному, не представляють набір значень, а також не зустрічаються явно в програмах. Вони вводяться в цій доповіді як внутрішні типи визначених ідентифікаторів.

Типі методів

Метод типів визначається внутрішньо як (Ps)U, де (Ps) є послідовністю імен параметрів та типів  (p1:T1,…,pn:Tn) для деякого n≥0 та U є типом (значення або метода). Цей тип представляє іменовані методи, що сприймає іменовані аргументи p1,…,pn типів T1,…,Tn, та що повертає результат типу U.

Типи методів асоціюються зправа: (Ps1)(Ps2)U трактується як (Ps1)((Ps2)U).

Спеціальним випадком є типи методів без параметрів. Вони записуються як => T. Методи без параметрів іменують вирази, що пере-обчислюються кожного разу, коли посилаються на ім'я такого методу .

Типи методів не існують як типи значень. Якщо ім'я метода використовується як значення, його тип неявно конвертується до відповідного функціонального типу. 

Приклад

Декларації

def a: Int
def b (x: Int): Boolean
def c (x: Int) (y: String, z: String): String

продукують типізації

a: => Int
b: (Int) Boolean
c: (Int) (String, String) String

Типи поліморфних методів

Тип поліморфного метода позначається внутрішньо як [tps]T , де [tps] є розділом типових параметрів [a1 >: L1 <: U1,…,an >: Ln <: Un] для деякого n≥0, та T є типом (значення або методу). Цей тип представляє іменовані методи, що сприймають типові аргументи S1,…,Sn, що задовільняють до нижніх меж L1,…,Ln та верхніх обмежень U1,…,Un, дають результати типу T.

Приклад

Декларації

def empty[A]: List[A]
def union[A <: Comparable[A]] (x: Set[A], xs: Set[A]): Set[A]

продукують типізації

empty : [A >: Nothing <: Any] List[A]
union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A]

Конструктори типів

Конструктор типу представлений внутрішньо, здебільшо як метод поліморфного методу. [± a1 >: L1 <: U1,…,±an >: Ln <: Un] T представляє тип, що очікується параметром конструктора типу або прив'язкою абстрактного конструктора типу з відповідним твердженням типового параметру. 

Приклад

Розлянемо цей фрагмент класу Iterable[+X]:

trait Iterable[+X] {
  def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S]
}

Концептуально, конструктор типу Iterable є ім'ям для анонімного типу [+X] Iterable[X], що може бути переданий до параметра конструктора типу newType у flatMap.

Базові типи та визначення членів

Типи членів класів залежать від шляху, яким посилаються на члени. Центральними тут є три нотації, а саме:

1. нотація набору базових типів типу T,
2. нотація типу T в деякому класі C видимого з деякого префіксного типу S,
3. нотація набору прив'язок члена до деякого типу T.

Ці нотації визначені взаємно рекурсивно наступним чином.

1. Набір базових типів типу є набір класових типів, наданих таким чином.

   • Базові типи класу типу C з батьками T1,…,Tn  є самий C, а також базові типи складного типу T1 with … with Tn { R }.
   • Базові типи типу-псевдоніму є базові типи його псевдо.
   • Базові типи абстрактного типу є базовими типами верхньої межі.
   • Базові типи параметризованого типу C[T1,…,Tn] є базові типи типу C, де кожне входження параметру типу ai до C було замінене на відповідний параметр типу Ti.
   • Базові типи типу сінглтону p.type є базові типи типу p.
   • Базові типи складного типу  T1 with … with Tn { R}  є скорочене об'єднання базових класів всіх Ti's. Це означає: Нехай мульти-множина S буде мульті-множиною-об'єднанням базових типів для всіх  Ti's. Якщо S містить декілька примірників типу того ж класу, скажімо Si#C[Ti1,…,Tin] (i∈I), тоді всі ці примірники замінюються одним з них, що відповідає до всіх інших. Буде помилкою, якщо такого примірника не існує. З цього слідує, що скорочене об'єднання, якщо таке існує, продукує множину класових типів, де різні типи є примірниками різних класів. 
   • Базові типи типу селекції S#T визначаються наступним чином. Якщо T є псевдонімом або абстрактним типом, застосовуються попередні твердження. Інакше T мусить бути (можливо параметризованим) класовим типом, що визначений в деякому класі B. Тоді базові типи S#T є базовими типами T в B видимі з префіксу типу S.
   • Базові типи екзістенціального типу T forSome { Q } є всі типи S forSome { Q }, де S є базовим типом T.

2. Нотація типу T в класі C видимого з деякого префіксу типу S має сенс, тільки якщо префікс типу S має примірник типу класу C в якості базового, скажімо, S′#C[T1,…,Tn]. Тоді ми визначаємо наступне.

   • Якщо S = ϵ.type, тоді T в C видимий з S є самий T.
   • Інакше, якщо S є екзістенціальним типом S′ forSome { Q }, та T в C видимий з S′ є T′, тоді T в C видимий з S isT′ forSome {Q}.
   • Інакше, якщо T є  i'тий параметр типу деякого класу D, тоді
     • Якщо S має базовий тип D[U1,…,Un], для деяких параметрів типу [U1,…,Un], тоді T в C видимий з S є Ui.
     • Інакше, якщо C визначений в класі C′, тодя T в C видимий з S є такий самий, як T в C′ видимий з S′.
     • Інакше, якщо C не визначений в іншому класі, тоді T в C видимий з S є самий T.
   • Інакше, якщо T є тип синглтона D.this.type для деякого класу D , тоді
     
     • Якщо D є субкласом C та S має примірник типу класу D серед своїх базових типів, тоді T в C видимий з S є S.
     • Інакше, якщо C визначений в класі C′, тоді T в C видимий з S є такий самий, як T в C′видимий з S′.
     • Інакше, якщо C не визначений в іншому класі, тоді T в C видимий з S є самий T.
   • Якщо T якогось іншого типу, тоді описане відображення виконується до всіх компонент типу.

   Якщо T є можливо параметризованим класовим типом, де T' клас визначений в деякому іншому класі D, та S є деякий префіксний тип, тоді ми використовуємо "T видимий з S" як скорочення для "T в D видимий з S".

3. Прив'язки членів типу T наступні

   1. всі прив'язки d , такі що існує примірник деякого класу  C серед базових типів T , та існує визначення або декларація d′ в C , така що d отримується з d′ заміною кожного типу T′ в d′ на T′ в C видимий з T, та
   2. всі прив'язки уточнення типу, якщо він має таке.